Thread: [GCC] Compiling for a generic x86 architecture

Question: why do you want to use this option?

I know next to nothing about this kind of thing, if you mean you are "cross compiling" -- that is, compiling for an architecture other than the one you are compiling on.

If you just want to compile and run the program on the computer you are currently using, you don't need to use this switch.

Originally Posted by mario++

The problem is that I don't need an executable optimized for my machine but a generic executable for the most common processors. And on linux it works fine...

So you are not already using x86 machine? Again, I don't know much about this, but if you do not use -mtune, then code compiled on an x86 will run fine on all other x86 (AMD, intel) systems. In other words, not using it does not mean it "defaults" to -mtune=native, it simply means none of the potential mtune optimizations will be used. Which for something like "hello world", those optimizations will be totally irrelevant.

Anyway, probably the gcc versions are different. You can get the version w/ "gcc -v". Probably MinGW does not have all the features of the gcc you are using on linux.

Originally Posted by mario++

What does -mtune=generic mean on Linux? Do it mean -mtune=i386?

Like I said, I've never used this option, and I think you have been distracted by it and believe it possess some significance it does not have (no big deal). I believe the purpose of mtune would mostly be for "cross compiling", where you are compiling an executable that will not run on the machine it is compiled on, but instead, a completely different piece of hardware, or to optimize for a particular machine including the one you are compiling on. But this is not necessary for hello world.

You would only want to think about this if you are aware of some feature of your processor that you are trying to exploit. If this feature is specific to a particular processor, then the compiler will not use it unless:

1) it knows about it, ie, the compiler has been designed with such potential.
2) you instruct the compiler to use those processor specific features with a switch such as this one.

By "feature" I mean specific asm (assembly) level commands (don't ask me for any, I dunno assembly!) If you are familiar with these things, -mtune may be interesting to you. If not, don't worry about it.

The "generic" option is described this way:

Originally Posted by man gcc

generic
Produce code optimized for the most common IA32/AMD64/EM64T
processors. If you know the CPU on which your code will run,
then you should use the corresponding -mtune option instead of
-mtune=generic. But, if you do not know exactly what CPU users
of your application will have, then you should use this option.

As new processors are deployed in the marketplace, the behavior
of this option will change. Therefore, if you upgrade to a
newer version of GCC, the code generated option will change to
reflect the processors that were most common when that version
of GCC was released.

What I take from this is: there are some new features that are common to many or most newer x86 processors that are still not part of the basic x86 set of (asm) instructions. So "generic" will exploit those. However, that means there will still be some x86's that don't use these features that your code will now not work on!

If your goal is to compile an executable that will run on all x86 processors then don't use -mtune! This is not used to select the processor! You don't have to do that!

Originally Posted by User Name:

MinGW(and all other cross compilers) has serious bugs

hyperbole much?

every compiler has bugs. MinGW is entirely suitable for 99.99% of the needs of any C programmer on these boards. The dude obviously isnt building a real-time operating system


.

Originally Posted by User Name:

"-m32" tells gcc to produce code for 32 bit protected/compatibility mode. That has to do with the type of assembly it produces. Calling conventions are also different in 64 bit mode(the successor to 32 bit). And, like you mentioned, variable sizes are different in different modes.

"-mtune=*", from what I can tell, just narrows what processors gcc will optimize for(kinda like , with generic as you're using, gcc will avoid any SSE* or other instruction sets that were introduced after the 80386. Put simply, it's worthless, don't use it, unless you really know why you're using it.

Telling ld to link it as a pei-i386 will imply you want i386 code. And you would get errors if something was wrong that would cause the code not to be for the i386.

You're not going to get the same build to run on Linux and Windows. It's a problem of executable formats, the info in executables that describes to the OS how to load the executable into memory is OS specific, what's perfectly clear to NT will make no sense to Linux.

What Windows are you testing on, is it x86 or x64? And what Linux(i386 or x86-64)? I'll give you the exact command line to build with, but I have to know what mode those OSes are running in.

My Windows 7 runs in x86 mode (CPU: Athlon 64), and Debian i386 (CPU AMD Athlon XP).

As I said, my intention is to produce a code (two executables, one for Windows OS and the other for Linux) that will work best way on most of the end-users computers.